package persistencia.pruebas;


import static org.junit.Assert.assertTrue;

import java.io.File;
import java.util.Set;
import java.util.TreeSet;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import compartido.Comparador;
import compartido.IEntidad;

import persistencia.IGondola;
import persistencia.carreras.ClaveValor;
import persistencia.carreras.EnsambladorClaveValor;
import persistencia.compartido.Tipo;
import persistencia.csv.AlmacenCSV;
import persistencia.csv.GondolaCSV;
import persistencia.excepciones.StringDeConexionIncompatible;

public class TestGondolasHerenciaSimple {

	protected Set<String> archivos;
	AlmacenCSV almacen;
	GondolaCSV unos;
	GondolaCSV dos;
	
	public class CVA extends ClaveValor {
		public CVA(String identificador, String valor) {
			super(identificador,valor);
		}
	}

	public class CVB extends ClaveValor {
		public CVB(String identificador, String valor) {
			super(identificador,valor);
		}
	}
	
	@Before
	public void setUp() throws Exception {
		almacen = new AlmacenCSV();
		
		try {
			almacen.abrir(".");
		} catch (StringDeConexionIncompatible e) {
			e.printStackTrace();
		}

		Tipo<IEntidad> tipoA = new Tipo<IEntidad>(CVA.class);
		Tipo<IEntidad> tipoB = new Tipo<IEntidad>(CVB.class);
		//Tipo<IEntidad> tipoClaveValor = new Tipo<IEntidad>(ClaveValor.class);
		//almacen.registrarEnsamblador(tipoClaveValor, new EnsambladorClaveValor());
		almacen.registrarEnsamblador(tipoA, new EnsambladorClaveValor());
		almacen.registrarEnsamblador(tipoB, new EnsambladorClaveValor());
		unos = (GondolaCSV)almacen.crearGondola(tipoA);
		dos = (GondolaCSV)almacen.crearGondola(tipoB);
		
		archivos = new TreeSet<String>();
//		archivos.add(tipoA.getNombre()+".csv");
//		archivos.add(tipoB.getNombre()+".csv");
	}

	@After
	public void tearDown() throws Exception {
		for (String nombre : archivos) {
			File archivo = new File(nombre);
			if (archivo.exists())
				archivo.delete();
		}
	}
		
	public class igualClaveValor implements Comparador<ClaveValor> {

		@Override
		public int comparar(ClaveValor a, ClaveValor b) {
			return a.compareTo(b);
		}

		@Override
		public int compare(ClaveValor o1, ClaveValor o2) {
			return comparar(o1, o2);
		}
		
	}
	
	@Test
	public void CargarGondolasConDatos_ComprobarQueSeanIguales_Correcto() {
		TreeSet<CVA> mapaUnos = new TreeSet<CVA>(new igualClaveValor());
		mapaUnos.add(new CVA("1","1"));
		mapaUnos.add(new CVA("2","11"));
		mapaUnos.add(new CVA("3","111"));
		mapaUnos.add(new CVA("4","1111"));
		mapaUnos.add(new CVA("5","11111"));

		TreeSet<CVB> mapaDos = new TreeSet<CVB>(new igualClaveValor());
		mapaDos.add(new CVB("1","2"));
		mapaDos.add(new CVB("2","22"));
		mapaDos.add(new CVB("3","222"));
		mapaDos.add(new CVB("4","2222"));
		mapaDos.add(new CVB("5","22222"));
		
		for (CVA claveValor : mapaUnos)
			unos.agregar(claveValor);

		for (CVB claveValor : mapaDos)
			dos.agregar(claveValor);
		
		almacen.cerrar();
		
		try {
			almacen.abrir(".");
		} catch (StringDeConexionIncompatible e) {
		}

		IGondola leido_unos = almacen.crearGondola(new Tipo<IEntidad>(CVA.class));
		IGondola leido_dos = almacen.crearGondola(new Tipo<IEntidad>(CVB.class));
		
		for (IEntidad entidad : leido_unos) {
			ClaveValor leido = (ClaveValor)entidad;
			assertTrue(mapaUnos.contains(leido));
		}
		
		for (IEntidad entidad : leido_dos) {
			ClaveValor leido = (ClaveValor)entidad;
			assertTrue(mapaDos.contains(leido));
		}
		
		almacen.cerrar();
	}

}
